{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-09T11:15:45.599678Z",
     "start_time": "2025-01-09T11:15:43.821411Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# DictVectorizer是将字典数据转换为特征向量的工具，可以将字典数据中的类别数据转换为特征。（sparse=true）时输出的是稀疏矩阵，即不含零值的矩阵。"
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                               {'city': '上海', 'temperature': 60},\n",
    "                               {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())#输出每个特征\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:17:39.102819Z",
     "start_time": "2025-01-09T11:17:39.097451Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# CountVectorizer是将文本数据转换为特征向量的工具，可以将文本数据转换为特征。"
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df：指的是每个词的文档频率不超过最大值，min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(res)\n",
    "    print('-'*50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-'*50)\n",
    "    print(res.toarray()) #稀疏矩阵转换为数组\n",
    "    print('-'*50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:37:47.542049Z",
     "start_time": "2025-01-09T11:37:47.535550Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# CountVectorizer是将文本数据转换为特征向量的工具，可以将文本数据转换为特征。"
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '喜欢']\n",
      "--------------------------------------------------\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我 喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(data) #稀疏存储，只记录非零位置\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-07-10T03:20:52.117629200Z",
     "start_time": "2024-07-10T03:20:52.105434800Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# jieba是Python中用于中文分词的库，可以将中文文本进行分词，jieba.cut()方法可以对中文文本进行分词。"
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword() #jieba分词好的中文文本\n",
    "    print('-'*50)\n",
    "    print(c1)\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-'*50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T11:54:42.039405Z",
     "start_time": "2025-01-09T11:54:42.031655Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# TfidfVectorizer用于将文本数据转换为 TF-IDF 特征矩阵。TF = (词在文档中出现的次数) / (文档中的总词数)表示词的频率, IDF = log(总文档数 / 包含该词的文档数 + 1)表示词的重要性。"
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True，即使用idf\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(type(data))\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:16:27.246896Z",
     "start_time": "2025-01-09T12:16:27.230732Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# MinMaxScaler是对数据进行缩放，使数据在一个固定范围内，即0-1之间，或者通过将每个特征的值缩放到给定的最小值和最大值之间，来标准化数据。"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值"
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-'*50)\n",
    "    out=mm.transform([[1, 2, 3, 4],[6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:32:04.634654Z",
     "start_time": "2025-01-09T12:32:04.626909Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "data": {
      "text/plain": "-1.9666666666666666"
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1-60)/30"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T01:56:23.103848700Z",
     "start_time": "2024-07-11T01:56:23.052804200Z"
    }
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# StandardScaler是对数据进行标准化，即将数据转换为均值为0，方差为1的分布。"
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data=stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:36:48.810604Z",
     "start_time": "2025-01-09T12:36:48.797039Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:36:51.358380Z",
     "start_time": "2025-01-09T12:36:51.352807Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform(data)\n",
    "print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:40:37.862917Z",
     "start_time": "2025-01-09T12:40:37.854408Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "[-1.48029737e-16  7.40148683e-17  7.40148683e-17]\n",
      "[1. 1. 1.]\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# square是平方，sqrt是开方"
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "data": {
      "text/plain": "1.5555556666666668"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.square(1-2.333)+np.square(2-2.333)+np.square(4-2.333))/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-16T03:27:52.239803100Z",
     "start_time": "2024-04-16T03:27:52.199808400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "-1.068779614944516"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1-2.333)/np.sqrt(1.55555)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-16T03:28:08.971612200Z",
     "start_time": "2024-04-16T03:28:08.956621100Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# SimpleImputer是用于处理缺失值，可以用众数、平均值、中位数、自定义值填补缺失值。fit_transform() 方法可以一步完成拟合和转换"
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:NOne\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')#平均值填补\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-07-11T02:23:07.050388100Z",
     "start_time": "2024-07-11T02:23:07.037320600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "3.6666666666666665"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "11/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:22:34.367453500Z",
     "start_time": "2024-07-11T02:22:34.322497700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "nan"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nan+10"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:23:44.133095700Z",
     "start_time": "2024-07-11T02:23:44.114673600Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（模型的参数减少了）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "#VarianceThreshold是用于删除低方差的特征，可以选择删除方差小于指定阈值的特征。 默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征"
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:59:53.991673Z",
     "start_time": "2025-01-09T12:59:53.978303Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# PCA是主成分分析，用于降维，可以选择保留方差最大的n个主成分，或者保留方差比例最大的n个主成分。"
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。(降维后的数据方差和原有数据方差之比要大于90%)\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]])#3行4列  \n",
    "    print(np.var(original_value, axis=0).sum()) #最初数据的方差,每一列的方差之和\n",
    "    print('-'* 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差\n",
    "    print(np.var(data, axis=0).sum())#data的方差,每一列的方差之和,这里有2个方差\n",
    "    print('-'*50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T13:27:47.818139Z",
     "start_time": "2025-01-09T13:27:47.812030Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 32
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "data": {
      "text/plain": "0.7499999999999999"
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "22/29.333333333333336"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T03:08:17.259124100Z",
     "start_time": "2024-07-11T03:08:17.248038900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "x = np.random.rand(10000) #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t,x,'g.',label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T03:12:01.965795700Z",
     "start_time": "2024-07-11T03:12:00.596774500Z"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
